home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / os2 / pvm34b3.zip / pvm34b3 / pvm3 / xep / TrueColorFix < prev    next >
Internet Message Format  |  1997-07-22  |  11KB
  1. Received: from msr.epm.ornl.gov by CS.UTK.EDU with SMTP (cf v2.9s-UTK)
  2.     id EAA23496; Mon, 11 Jul 1994 04:48:33 -0400
  3. Received: from appana.ap.titech.ac.jp by msr.epm.ornl.gov (4.1/1.34)
  4.     id AA28611; Mon, 11 Jul 94 04:46:41 EDT
  5. Received: by appana.ap.titech.ac.jp (5.65+1.6W/tit-mx1.1); Mon, 11 Jul 94 17:45:55 +0900
  6. Received: by wisdom.ap.titech.ac.jp (NX5.67c/NX3.0S)
  7.     id AA12748; Mon, 11 Jul 94 17:46:04 +0900
  8. Date: Mon, 11 Jul 94 17:46:04 +0900
  9. From: Satoshi Adachi <adachi@wisdom.ap.titech.ac.jp>
  10. Message-Id: <9407110846.AA12748@wisdom.ap.titech.ac.jp>
  11. To: pvm@msr.epm.ornl.gov
  12. Subject: Modifications of xep necessary for NeXTstation Color.
  13. Cc: adachi@wisdom.ap.titech.ac.jp
  14.  
  15.  
  16. Dear Scientists and Engineers who have been developing PVM:
  17.  
  18. (1) Recently, I was informed by my friend that there is a very nice
  19. software system, called PVM, that enable us to look a cluster of
  20. many workstations as a single virtual machine and to write
  21. parallel programs for the virtual machine. So, I installed
  22. PVM3.2.4 for our workstation cluster of NeXTstation's and IBM RS6000's.
  23. Now, PVM works very well on our workstation cluster.
  24. I have just begun writing several programs for physics by using PVM.
  25. Thank you very much for developing such a nice software system
  26. and for making it a free software.
  27.  
  28. In the installation of PVM3.2.4, the body part of PVM did not need
  29. any change of source code and the installcation was completely automatic.
  30. However, the installtion of the demo program "xep" for NeXTstation color
  31. needed some change of source code.
  32.  
  33. In this email, I will explain the modification of the source code of "xep"
  34. which is necessary to run "xep" on NeXTstation Color and NeXTstation Color
  35. Turbo.
  36.  
  37. I hope that the modification or its equivalent will be incorpolated in
  38. the future releases of "xep".
  39.  
  40. (2) Our NeXTstaion Color's and NeXTstation Color Turbo's are running
  41. under NeXTSTEP 3.0J and the commercial X Window software "Co-Xist"
  42. is installed on these machines.
  43.  
  44. For NeXTstaion Color and NeXTstation Color Turbo, the true color model is
  45. used rather than the pseudo color model. On the screen, each pixel directly
  46. corresponds to a binary number of 12 bit length. Namely, Red, Green and
  47. Blue intensities are expressed by 4 bit integers. In C programs, a pixel
  48. is prepresented by a short integer with 16 bit which consists of 12 bit
  49. RGB fields and 4 bit pad.
  50.  
  51. The source code of "xep" supports the not only the pseudo colode model
  52. but also the true color model. However, when the true color model is used,
  53. it is assumed that each pixel is expressed by the RGB value of 24 bit
  54. length (8 bit each) and is represented by 32 bit integer in C programs
  55. (including 8 bit pad).
  56.  
  57. This assumption supposed by "xep" does not hold for NeXTstation Color and
  58. NeXTstation Color Turbo. Consequently, "xep" abends on these machines with
  59. Co-Xist.
  60.  
  61. In order to support the true color model with RGB value represented by
  62. not only 3*8 bit but also 3*4 bit, I changed the source code of "xep"
  63. in the file "xep/xep.c" in the following way:
  64.  
  65. -------------------------------------------------------------------------------
  66. *** xep.c    Mon Jul 11 17:19:01 1994
  67. --- xep.c.org    Sat Jul  9 20:16:37 1994
  68. ***************
  69. *** 70,78 ****
  70.   
  71.   typedef    unsigned int IBIT32;
  72.   
  73. - /* ***** Added by S.Adachi (94/07/09) ***** */
  74. - typedef unsigned short int IBIT16;
  75. - 
  76.   /* describes an image canvas (currently only one) */
  77.   
  78.   struct canvas {
  79. --- 70,75 ----
  80. ***************
  81. *** 410,437 ****
  82.               }
  83.               xBpp = pfv[i].bits_per_pixel;
  84.               xBypp = xBpp / 8;
  85. -             /* ***** Modified by S.Adachi (94/07/10) ***** */
  86. - #if 0
  87.               redMask = defVis->red_mask;
  88.               redShift = ffs(redMask & ~(redMask >> 1)) - 8;
  89.               greenMask = defVis->green_mask;
  90.               greenShift = ffs(greenMask & ~(greenMask >> 1)) - 8;
  91.               blueMask = defVis->blue_mask;
  92.               blueShift = ffs(blueMask & ~(blueMask >> 1)) - 8;
  93. - #else
  94. -             if ((xBypp != 2) && (xBypp != 4)) {
  95. -               fprintf(stderr, "unsupported bytes per pixel: %d\n",
  96. -                   xBypp);
  97. -               exit(1);
  98. -             }
  99. -             redMask = defVis->red_mask;
  100. -             redShift = ffs(redMask) - 1;
  101. -             greenMask = defVis->green_mask;
  102. -             greenShift = ffs(greenMask) - 1;
  103. -             blueMask = defVis->blue_mask;
  104. -             blueShift = ffs(blueMask) - 1;
  105. - #endif /* Modification by S.Adachi (94/07/10) */
  106.               mkrbow(fclutr, fclutg, fclutb, 256);
  107.           } else {
  108.               isCmap = 1;
  109.               xCmap = DefaultColormap(xDisp, xScrn);
  110. --- 407,420 ----
  111.               }
  112.               xBpp = pfv[i].bits_per_pixel;
  113.               xBypp = xBpp / 8;
  114.               redMask = defVis->red_mask;
  115.               redShift = ffs(redMask & ~(redMask >> 1)) - 8;
  116.               greenMask = defVis->green_mask;
  117.               greenShift = ffs(greenMask & ~(greenMask >> 1)) - 8;
  118.               blueMask = defVis->blue_mask;
  119.               blueShift = ffs(blueMask & ~(blueMask >> 1)) - 8;
  120.               mkrbow(fclutr, fclutg, fclutb, 256);
  121. + 
  122.           } else {
  123.               isCmap = 1;
  124.               xCmap = DefaultColormap(xDisp, xScrn);
  125. ***************
  126. *** 1044,1068 ****
  127.       return x;
  128.   }
  129.   
  130. - /* ***** Added by S.Adachi (94/07/09) ***** */
  131. - /*    sw2()
  132. - *
  133. - *    Byteswap a 16-bit integer.
  134. - */
  135. - 
  136. - IBIT16
  137. - sw2(x)
  138. -     IBIT16 x;
  139. - {
  140. -     u_char *cp = (u_char*)&x;
  141. -     u_char c;
  142. - 
  143. -     c = cp[0];
  144. -     cp[0] = cp[1];
  145. -     cp[1] = c;
  146. -     return x;
  147. - }
  148. - 
  149.   
  150.   /*    repaint_region()
  151.   *
  152. --- 1027,1032 ----
  153. ***************
  154. *** 1133,1212 ****
  155.               dy = (y1 - cnp->cn_oy) * cnp->cn_zoom;
  156.               ya = 0;
  157.               while (sy < y2 && dy < cnp->cn_ht) {
  158. !               sx = x1;
  159. !               dx = (x1 - cnp->cn_ox) * cnp->cn_zoom;
  160. !               xa = 0;
  161. !               sa = ribuf + sy * cnp->cn_wd + sx;
  162. !               /* ***** Modified by S.Adachi (94/07/09) ***** */
  163. ! #if 0
  164. !               da = (ximbuf + dy * cnp->cn_xim->bytes_per_line
  165. !                 + dx * sizeof(IBIT32));
  166. !               while (sx < x2 && dx < cnp->cn_wd) {
  167. !                 pixv = lbm & *sa;
  168. !                 pixr = fclutr[pixv];
  169. !                 pixg = fclutg[pixv];
  170. !                 pixb = fclutb[pixv];
  171. !                 pixv = (redMask & (pixr << redShift))
  172. !                   | (greenMask & (pixg << greenShift))
  173. !                 | (blueMask & (pixb << blueShift));
  174. !                 if (revByte)
  175. !                   *((IBIT32*)da) = sw4(pixv);
  176. !                 else
  177. !                   *((IBIT32*)da) = pixv;
  178. !                 da += sizeof(IBIT32);
  179. !                 dx++;
  180. !                 if (++xa >= cnp->cn_zoom) {
  181. !                   xa = 0;
  182. !                   sx++;
  183. !                   sa++;
  184. !                 }
  185. !               }
  186. ! #else
  187. !               da = (ximbuf + dy * cnp->cn_xim->bytes_per_line
  188. !                 + dx * xBypp);
  189. !               while (sx < x2 && dx < cnp->cn_wd) {
  190. !                 pixv = lbm & *sa;
  191. !                 pixr = fclutr[pixv];
  192. !                 pixg = fclutg[pixv];
  193. !                 pixb = fclutb[pixv];
  194. !                 if (xBypp == 4) {
  195. !                   pixv = ((redMask & (pixr << redShift))
  196. !                       |(greenMask & (pixg << greenShift))
  197. !                       |(blueMask & (pixb << blueShift)));
  198. !                   if (revByte)
  199. !                 *((IBIT32*)da) = sw4(pixv);
  200. !                   else
  201. !                 *((IBIT32*)da) = pixv;
  202. !                   da += sizeof(IBIT32);
  203. !                 }
  204. !                 else {
  205. !                   /* xBypp == 2 */
  206. !                   IBIT16 pixvs;
  207. !                   pixr = pixr >> 4;
  208. !                   pixg = pixg >> 4;
  209. !                   pixb = pixb >> 4;
  210. !                   pixvs = ((redMask & (pixr << redShift))
  211. !                        |(greenMask & (pixg << greenShift))
  212. !                        |(blueMask & (pixb << blueShift)));
  213. !                   if (revByte)
  214. !                 *((IBIT16*)da) = sw2(pixvs);
  215. !                   else
  216. !                 *((IBIT16*)da) = pixvs;
  217. !                   da += sizeof(IBIT16);
  218. !                 }
  219. !                 dx++;
  220. !                 if (++xa >= cnp->cn_zoom) {
  221. !                   xa = 0;
  222. !                   sx++;
  223. !                   sa++;
  224. !                 }
  225. !               }
  226. ! #endif /* ***** End of Modification by S.Adachi (94/07/10) ***** */
  227. !               dy++;
  228. !               if (++ya >= cnp->cn_zoom) {
  229. !                 ya = 0;
  230. !                 sy++;
  231. !               }
  232.               }
  233.           }
  234.   
  235. --- 1097,1133 ----
  236.               dy = (y1 - cnp->cn_oy) * cnp->cn_zoom;
  237.               ya = 0;
  238.               while (sy < y2 && dy < cnp->cn_ht) {
  239. !                 sx = x1;
  240. !                 dx = (x1 - cnp->cn_ox) * cnp->cn_zoom;
  241. !                 xa = 0;
  242. !                 sa = ribuf + sy * cnp->cn_wd + sx;
  243. !                 da = ximbuf + dy * cnp->cn_xim->bytes_per_line + dx * sizeof(IBIT32);
  244. !                 while (sx < x2 && dx < cnp->cn_wd) {
  245. !                     pixv = lbm & *sa;
  246. !                     pixr = fclutr[pixv];
  247. !                     pixg = fclutg[pixv];
  248. !                     pixb = fclutb[pixv];
  249. !                     pixv = (redMask & (pixr << redShift))
  250. !                             | (greenMask & (pixg << greenShift))
  251. !                             | (blueMask & (pixb << blueShift));
  252. !                     if (revByte)
  253. !                         *((IBIT32*)da) = sw4(pixv);
  254. !                     else
  255. !                         *((IBIT32*)da) = pixv;
  256. !         
  257. !                     da += sizeof(IBIT32);
  258. !                     dx++;
  259. !                     if (++xa >= cnp->cn_zoom) {
  260. !                         xa = 0;
  261. !                         sx++;
  262. !                         sa++;
  263. !                     }
  264. !                 }
  265. !                 dy++;
  266. !                 if (++ya >= cnp->cn_zoom) {
  267. !                     ya = 0;
  268. !                     sy++;
  269. !                 }
  270.               }
  271.           }
  272.   
  273. -------------------------------------------------------------------------------
  274.  
  275. I would like to make several remarks on the above modifications:
  276.  
  277. (i) In contrast to IBIT32 for the RGB value represented in 32 bit,
  278. a new type IBIT 16 is introduced for the RGB value represented in 16 bit as:
  279.  
  280.     typedef unsigned short int IBIT16;
  281.  
  282. (ii) In order to confirm that when the true color model is used, the RGB value
  283. is represented in either 16 bit or 32 bit, the following code is added:
  284.  
  285.         if ((xBypp != 2) && (xBypp != 4)) {
  286.           fprintf(stderr, "unsupported bytes per pixel: %d\n",
  287.               xBypp);
  288.           exit(1);
  289.         }
  290.  
  291. (iii) The original code to calculate the shift for the red field in the RGB
  292. value was
  293.  
  294.         redShift = ffs(redMask & ~(redMask >> 1)) - 8;
  295.  
  296. This assumes that the field has 8 bit length. This is changed to
  297.  
  298.         redShift = ffs(redMask) - 1;
  299.  
  300. Same is true for the fields of Green and Blue. This new code may have some
  301. problem on the respect to byte order mismatch between X server and X client.
  302. I am not sure. I did not inspect it.
  303.  
  304. (iv) A new function "sw2()" is added. This is the 16 bit version of sw4().
  305.  
  306. (v) The following code assumes that each pixel is represented by 32 bit
  307. integer:
  308.  
  309.           da = (ximbuf + dy * cnp->cn_xim->bytes_per_line
  310.             + dx * sizeof(IBIT32));
  311.  
  312. In the new code, "sizeof(IBIT32)" is replaced by "xBypp".
  313.  
  314. (vi) When a pixel value is written in memory, the following "if" statement
  315. is introduced to respect the bit length of the pixel:
  316.  
  317.             if (xBypp == 4) {
  318.  
  319.             /* Same as the original code */
  320.  
  321.             }
  322.             else {
  323.               /* xBypp == 2 */
  324.               IBIT16 pixvs;
  325.               pixr = pixr >> 4;
  326.               pixg = pixg >> 4;
  327.               pixb = pixb >> 4;
  328.               pixvs = ((redMask & (pixr << redShift))
  329.                    |(greenMask & (pixg << greenShift))
  330.                    |(blueMask & (pixb << blueShift)));
  331.               if (revByte)
  332.             *((IBIT16*)da) = sw2(pixvs);
  333.               else
  334.             *((IBIT16*)da) = pixvs;
  335.               da += sizeof(IBIT16);
  336.             }
  337.  
  338. We should be careful that the original pixr, pixg, pixb values are
  339. in the range 0-255.
  340.  
  341. Thank you very much.
  342.  
  343. Satoshi Adachi
  344. (adachi@wisdom.ap.titech.ac.jp)
  345.  
  346. Research Associate
  347. Department of Applied Physics
  348. Tokyo Institute of Technology
  349. Meguro, Tokyo 152, JAPAN
  350.